21. juli 2025Norsk

Mestre avanserte Jest-testmønstre for å bygge mer pålitelig og vedlikeholdbar programvare. Utforsk teknikker som mocking, snapshot-testing, egendefinerte matchere og mer for globale utviklingsteam.

Jest: Avanserte testmønstre for robust programvare

I dagens hektiske landskap for programvareutvikling er det avgjørende å sikre påliteligheten og stabiliteten til kodebasen din. Selv om Jest har blitt en de facto-standard for JavaScript-testing, åpner det å gå utover grunnleggende enhetstester opp et nytt nivå av tillit til applikasjonene dine. Dette innlegget dykker ned i avanserte Jest-testmønstre som er essensielle for å bygge robust programvare, rettet mot et globalt publikum av utviklere.

Hvorfor gå utover grunnleggende enhetstester?

Grunnleggende enhetstester verifiserer individuelle komponenter isolert. Imidlertid er virkelige applikasjoner komplekse systemer der komponenter samhandler. Avanserte testmønstre adresserer disse kompleksitetene ved å gjøre oss i stand til å:

Simulere komplekse avhengigheter.
Fange opp UI-endringer på en pålitelig måte.
Skrive mer uttrykksfulle og vedlikeholdbare tester.
Forbedre testdekning og tillit til integrasjonspunkter.
Fasilitere arbeidsflyter for testdrevet utvikling (TDD) og atferdsdrevet utvikling (BDD).

Mestring av mocking og spioner

Mocking er avgjørende for å isolere enheten som testes ved å erstatte dens avhengigheter med kontrollerte substitutter. Jest tilbyr kraftige verktøy for dette:

`jest.fn()`: Grunnlaget for mocks og spioner

jest.fn() oppretter en mock-funksjon. Du kan spore dens kall, argumenter og returverdier. Dette er byggesteinen for mer sofistikerte mocking-strategier.

Eksempel: Spore funksjonskall

            // component.js
export const fetchData = () => {
  // Simulerer et API-kall
  return Promise.resolve({ data: 'some data' });
};

export const processData = async (fetcher) => {
  const result = await fetcher();
  return `Processed: ${result.data}`;
};

// component.test.js
import { processData } from './component';

test('should process data correctly', async () => {
  const mockFetcher = jest.fn().mockResolvedValue({ data: 'mocked data' });
  const result = await processData(mockFetcher);
  expect(result).toBe('Processed: mocked data');
  expect(mockFetcher).toHaveBeenCalledTimes(1);
  expect(mockFetcher).toHaveBeenCalledWith();
});

`jest.spyOn()`: Observere uten å erstatte

jest.spyOn() lar deg observere kall til en metode på et eksisterende objekt uten nødvendigvis å erstatte implementasjonen. Du kan også mocke implementasjonen om nødvendig.

Eksempel: Spionere på en modulmetode

            // logger.js
export const logInfo = (message) => {
  console.log(`INFO: ${message}`);
};

// service.js
import { logInfo } from './logger';

export const performTask = (taskName) => {
  logInfo(`Starting task: ${taskName}`);
  // ... oppgavelogikk ...
  logInfo(`Task ${taskName} completed.`);
};

// service.test.js
import { performTask } from './service';
import * as logger from './logger';

test('should log task start and completion', () => {
  const logSpy = jest.spyOn(logger, 'logInfo');

  performTask('backup');

  expect(logSpy).toHaveBeenCalledTimes(2);
  expect(logSpy).toHaveBeenCalledWith('Starting task: backup');
  expect(logSpy).toHaveBeenCalledWith('Task backup completed.');

  logSpy.mockRestore(); // Viktig å gjenopprette den originale implementasjonen
});

Mocking av modulimporter

Jests kapabiliteter for modul-mocking er omfattende. Du kan mocke hele moduler eller spesifikke eksporteringer.

Eksempel: Mocking av en ekstern API-klient

            // api.js
import axios from 'axios';

export const getUser = async (userId) => {
  const response = await axios.get(`/api/users/${userId}`);
  return response.data;
};

// user-service.js
import { getUser } from './api';

export const getUserFullName = async (userId) => {
  const user = await getUser(userId);
  return `${user.firstName} ${user.lastName}`;
};

// user-service.test.js
import { getUserFullName } from './user-service';
import * as api from './api';

// Mock hele api-modulen
jest.mock('./api');

test('should get full name using mocked API', async () => {
  // Mock den spesifikke funksjonen fra den mockede modulen
  api.getUser.mockResolvedValue({ id: 1, firstName: 'Ada', lastName: 'Lovelace' });

  const fullName = await getUserFullName(1);

  expect(fullName).toBe('Ada Lovelace');
  expect(api.getUser).toHaveBeenCalledTimes(1);
  expect(api.getUser).toHaveBeenCalledWith(1);
});

Automatisk mocking vs. manuell mocking

Jest mocker automatisk Node.js-moduler. For ES-moduler eller egendefinerte moduler kan du trenge jest.mock(). For mer kontroll kan du opprette __mocks__-kataloger.

Mock-implementasjoner

Du kan tilby egendefinerte implementasjoner for dine mocks.

Eksempel: Mocking med en egendefinert implementasjon

            // math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// calculator.js
import { add, subtract } from './math';

export const calculate = (operation, a, b) => {
  if (operation === 'add') {
    return add(a, b);
  } else if (operation === 'subtract') {
    return subtract(a, b);
  }
  return null;
};

// calculator.test.js
import { calculate } from './calculator';
import * as math from './math';

// Mock hele math-modulen
jest.mock('./math');

test('should perform addition using mocked math add', () => {
  // Gi en mock-implementasjon for 'add'-funksjonen
  math.add.mockImplementation((a, b) => a + b + 10); // Legg til 10 i resultatet
  math.subtract.mockReturnValue(5); // Mock subtract også

  const result = calculate('add', 5, 3);

  expect(math.add).toHaveBeenCalledWith(5, 3);
  expect(result).toBe(18); // 5 + 3 + 10

  const subResult = calculate('subtract', 10, 2);
  expect(math.subtract).toHaveBeenCalledWith(10, 2);
  expect(subResult).toBe(5);
});

Snapshot-testing: Bevare brukergrensesnitt og konfigurasjon

Snapshot-tester er en kraftig funksjon for å fange opp utdataene fra dine komponenter eller konfigurasjoner. De er spesielt nyttige for UI-testing eller verifisering av komplekse datastrukturer.

Hvordan snapshot-testing fungerer

Første gang en snapshot-test kjøres, oppretter Jest en .snap-fil som inneholder en serialisert representasjon av den testede verdien. Ved påfølgende kjøringer sammenligner Jest de nåværende utdataene med det lagrede snapshotet. Hvis de avviker, feiler testen og varsler deg om utilsiktede endringer. Dette er uvurderlig for å oppdage regresjoner i UI-komponenter på tvers av forskjellige regioner eller lokaliteter.

Eksempel: Snapshot av en React-komponent

Anta at du har en React-komponent:

            // UserProfile.js
import React from 'react';

const UserProfile = ({ name, email, isActive }) => (
  <div>
    <h2>{name}</h2>
    <p><strong>E-post:</strong> {email}</p>
    <p><strong>Status:</strong> {isActive ? 'Aktiv' : 'Inaktiv'}</p>
  </div>
);

export default UserProfile;

// UserProfile.test.js
import React from 'react';
import renderer from 'react-test-renderer'; // For React-komponent-snapshots
import UserProfile from './UserProfile';

test('renders UserProfile correctly', () => {
  const user = {
    name: 'Jane Doe',
    email: 'jane.doe@example.com',
    isActive: true,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});

test('renders inactive UserProfile correctly', () => {
  const user = {
    name: 'John Smith',
    email: 'john.smith@example.com',
    isActive: false,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot('inactive user profile'); // Navngitt snapshot
});

Etter å ha kjørt testene, vil Jest opprette en UserProfile.test.js.snap-fil. Når du oppdaterer komponenten, må du gjennomgå endringene og eventuelt oppdatere snapshotet ved å kjøre Jest med --updateSnapshot- eller -u-flagget.

Beste praksis for snapshot-testing

Bruk for UI-komponenter og konfigurasjonsfiler: Ideelt for å sikre at UI-elementer rendres som forventet og at konfigurasjonen ikke endres utilsiktet.
Gjennomgå snapshots nøye: Ikke godta snapshot-oppdateringer blindt. Gjennomgå alltid hva som har endret seg for å sikre at modifikasjonene er tilsiktede.
Unngå snapshots for data som endres ofte: Hvis data endrer seg raskt, kan snapshots bli skjøre og føre til overdreven støy.
Bruk navngitte snapshots: For testing av flere tilstander av en komponent, gir navngitte snapshots bedre klarhet.

Egendefinerte matchere: Forbedre lesbarheten i tester

Jests innebygde matchere er omfattende, men noen ganger må du hevde spesifikke betingelser som ikke dekkes. Egendefinerte matchere lar deg lage din egen påstandslogikk, noe som gjør testene dine mer uttrykksfulle og lesbare.

Opprette egendefinerte matchere

Du kan utvide Jests expect-objekt med dine egne matchere.

Eksempel: Sjekke for et gyldig e-postformat

I din Jest-oppsettfil (f.eks. jest.setup.js, konfigurert i jest.config.js):

            // jest.setup.js

expect.extend({
  toBeValidEmail(received) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    const pass = emailRegex.test(received);

    if (pass) {
      return {
        message: () => `forventet at ${received} ikke skulle være en gyldig e-post`,
        pass: true,
      };
    } else {
      return {
        message: () => `forventet at ${received} skulle være en gyldig e-post`,
        pass: false,
      };
    }
  },
});

// In your jest.config.js
// module.exports = { setupFilesAfterEnv: ['/jest.setup.js'] };

I testfilen din:

            // validation.test.js

test('should validate email formats', () => {
  expect('test@example.com').toBeValidEmail();
  expect('invalid-email').not.toBeValidEmail();
  expect('another.test@sub.domain.co.uk').toBeValidEmail();
});

Fordeler med egendefinerte matchere

Forbedret lesbarhet: Tester blir mer deklarative, og angir *hva* som testes i stedet for *hvordan*.
Gjenbruk av kode: Unngå å gjenta kompleks påstandslogikk på tvers av flere tester.
Domenespesifikke påstander: Skreddersy påstander til applikasjonens spesifikke domenekrav.

Testing av asynkrone operasjoner

JavaScript er i stor grad asynkront. Jest gir utmerket støtte for testing av promises og async/await.

Bruke `async/await`

Dette er den moderne og mest lesbare måten å teste asynkron kode på.

Eksempel: Teste en asynkron funksjon

            // dataService.js
export const fetchUserData = async (userId) => {
  // Simulerer henting av data etter en forsinkelse
  await new Promise(resolve => setTimeout(resolve, 50));
  if (userId === 1) {
    return { id: 1, name: 'Alice' };
  } else {
    throw new Error('Bruker ikke funnet');
  }
};

// dataService.test.js
import { fetchUserData } from './dataService';

test('fetches user data correctly', async () => {
  const user = await fetchUserData(1);
  expect(user).toEqual({ id: 1, name: 'Alice' });
});

test('throws error for non-existent user', async () => {
  await expect(fetchUserData(2)).rejects.toThrow('Bruker ikke funnet');
});

Bruke `.resolves` og `.rejects`

Disse matcherne forenkler testing av promise-oppløsninger og -avvisninger.

Eksempel: Bruke .resolves/.rejects

            // dataService.test.js (continued)

test('fetches user data with .resolves', () => {
  return expect(fetchUserData(1)).resolves.toEqual({ id: 1, name: 'Alice' });
});

test('throws error for non-existent user with .rejects', () => {
  return expect(fetchUserData(2)).rejects.toThrow('Bruker ikke funnet');
});

Håndtere tidtakere

For funksjoner som bruker setTimeout eller setInterval, gir Jest kontroll over tidtakere.

Eksempel: Kontrollere tidtakere

            // delayedGreeter.js
export const greetAfterDelay = (name, callback) => {
  setTimeout(() => {
    callback(`Hallo, ${name}!`);
  }, 1000);
};

// delayedGreeter.test.js
import { greetAfterDelay } from './delayedGreeter';

jest.useFakeTimers(); // Aktiver falske tidtakere

test('greets after delay', () => {
  const mockCallback = jest.fn();
  greetAfterDelay('World', mockCallback);

  // Fremskynd tidtakerne med 1000ms
  jest.advanceTimersByTime(1000);

  expect(mockCallback).toHaveBeenCalledTimes(1);
  expect(mockCallback).toHaveBeenCalledWith('Hallo, World!');
});

// Gjenopprett ekte tidtakere hvis det trengs andre steder
jest.useRealTimers();

Testorganisering og struktur

Etter hvert som testsuiten din vokser, blir organisering avgjørende for vedlikeholdbarhet.

Describe-blokker og It-blokker

Bruk describe for å gruppere relaterte tester og it (eller test) for individuelle testtilfeller. Denne strukturen speiler applikasjonens modularitet.

Eksempel: Strukturerte tester

            describe('User Authentication Service', () => {
  let authService;

  beforeEach(() => {
    // Sett opp mocks eller tjenesteinstanser før hver test
    authService = require('./authService');
    jest.spyOn(authService, 'login').mockImplementation(() => Promise.resolve({ token: 'fake_token' }));
  });

  afterEach(() => {
    // Rydd opp i mocks
    jest.restoreAllMocks();
  });

  describe('login functionality', () => {
    it('should successfully log in a user with valid credentials', async () => {
      const result = await authService.login('user@example.com', 'password123');
      expect(result.token).toBeDefined();
      // ... flere påstander ...
    });

    it('should fail login with invalid credentials', async () => {
      jest.spyOn(authService, 'login').mockRejectedValue(new Error('Ugyldige legitimasjoner'));
      await expect(authService.login('user@example.com', 'wrong_password')).rejects.toThrow('Ugyldige legitimasjoner');
    });
  });

  describe('logout functionality', () => {
    it('should clear user session', async () => {
      // Test utloggingslogikk...
    });
  });
});

Oppsett- og nedriggings-hooks

beforeAll: Kjøres én gang før alle tester i en describe-blokk.
afterAll: Kjøres én gang etter alle tester i en describe-blokk.
beforeEach: Kjøres før hver test i en describe-blokk.
afterEach: Kjøres etter hver test i en describe-blokk.

Disse hooksene er essensielle for å sette opp mock-data, databaseforbindelser eller rydde opp i ressurser mellom tester.

Testing for et globalt publikum

Når man utvikler applikasjoner for et globalt publikum, utvides testhensynene:

Internasjonalisering (i18n) og lokalisering (l10n)

Sørg for at brukergrensesnittet og meldingene dine tilpasser seg korrekt til forskjellige språk og regionale formater.

Snapshotting av lokalisert UI: Test at forskjellige språkversjoner av brukergrensesnittet ditt rendres korrekt ved hjelp av snapshot-tester.
Mocking av lokaliseringsdata: Mock biblioteker som react-intl eller i18next for å teste komponentatferd med forskjellige lokaliserte meldinger.
Formatering av dato, tid og valuta: Test at disse håndteres korrekt ved hjelp av egendefinerte matchere eller ved å mocke internasjonaliseringsbiblioteker. For eksempel, verifiser at en dato formatert for Tyskland (DD.MM.YYYY) ser annerledes ut enn for USA (MM/DD/YYYY).

Eksempel: Testing av lokalisert datoformatering

            // dateUtils.js
export const formatLocalizedDate = (date, locale) => {
  return new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'numeric', day: 'numeric' }).format(date);
};

// dateUtils.test.js
import { formatLocalizedDate } from './dateUtils';

test('formaterer dato korrekt for amerikansk lokalitet', () => {
  const date = new Date(2023, 10, 15); // 15. november 2023
  expect(formatLocalizedDate(date, 'en-US')).toBe('11/15/2023');
});

test('formaterer dato korrekt for tysk lokalitet', () => {
  const date = new Date(2023, 10, 15);
  expect(formatLocalizedDate(date, 'de-DE')).toBe('15.11.2023');
});

Tidssonebevissthet

Test hvordan applikasjonen din håndterer forskjellige tidssoner, spesielt for funksjoner som planlegging eller sanntidsoppdateringer. Å mocke systemklokken eller bruke biblioteker som abstraherer tidssoner kan være fordelaktig.

Kulturelle nyanser i data

Vurder hvordan tall, valutaer og andre datarepresentasjoner kan oppfattes eller forventes annerledes på tvers av kulturer. Egendefinerte matchere kan være spesielt nyttige her.

Avanserte teknikker og strategier

Testdrevet utvikling (TDD) og atferdsdrevet utvikling (BDD)

Jest passer godt med TDD (Rød-Grønn-Refaktor) og BDD (Gitt-Når-Da) metodologier. Skriv tester som beskriver ønsket atferd før du skriver implementeringskoden. Dette sikrer at koden skrives med testbarhet i tankene fra starten av.

Integrasjonstesting med Jest

Selv om Jest utmerker seg på enhetstester, kan det også brukes til integrasjonstester. Å mocke færre avhengigheter eller bruke verktøy som Jests runInBand-alternativ kan hjelpe.

Eksempel: Testing av API-interaksjon (forenklet)

            // apiService.js
import axios from 'axios';

const API_BASE_URL = 'https://api.example.com';

export const createProduct = async (productData) => {
  const response = await axios.post(`${API_BASE_URL}/products`, productData);
  return response.data;
};

// apiService.test.js (Integrasjonstest)
import axios from 'axios';
import { createProduct } from './apiService';

// Mock axios for integrasjonstester for å kontrollere nettverkslaget
jest.mock('axios');

test('oppretter et produkt via API', async () => {
  const mockProduct = { id: 1, name: 'Gadget' };
  const responseData = { success: true, product: mockProduct };

  axios.post.mockResolvedValue({
    data: responseData,
    status: 201,
    headers: { 'content-type': 'application/json' },
  });

  const newProductData = { name: 'Gadget', price: 99.99 };
  const result = await createProduct(newProductData);

  expect(axios.post).toHaveBeenCalledWith(`${process.env.API_BASE_URL || 'https://api.example.com'}/products`, newProductData);
  expect(result).toEqual(responseData);
});

Parallellisme og konfigurasjon

Jest kan kjøre tester parallelt for å øke hastigheten på kjøringen. Konfigurer dette i din jest.config.js. For eksempel kontrollerer innstillingen maxWorkers antall parallelle prosesser.

Dekkingsrapporter

Bruk Jests innebygde dekningsrapportering for å identifisere deler av kodebasen din som ikke blir testet. Kjør tester med --coverage for å generere detaljerte rapporter.

            jest --coverage

Å gjennomgå dekningsrapporter hjelper med å sikre at dine avanserte testmønstre effektivt dekker kritisk logikk, inkludert kodebaner for internasjonalisering og lokalisering.

Konklusjon

Å mestre avanserte Jest-testmønstre er et betydelig skritt mot å bygge pålitelig, vedlikeholdbar og høykvalitets programvare for et globalt publikum. Ved å effektivt utnytte mocking, snapshot-testing, egendefinerte matchere og asynkrone testteknikker, kan du forbedre robustheten til testsuiten din og få større tillit til applikasjonens atferd på tvers av ulike scenarier og regioner. Å omfavne disse mønstrene gir utviklingsteam over hele verden mulighet til å levere eksepsjonelle brukeropplevelser.

Begynn å innlemme disse avanserte teknikkene i arbeidsflyten din i dag for å heve din JavaScript-testpraksis.